const AdmZip = require('adm-zip');
const path = require('path');
const fs = require("fs");
const iconv = require('iconv-lite');
const Log = require("ee-core/log");
const { target } = require("./fileTools"); // 用于编码转换

function extract (zipFilePath, targetDir) {

	return new Promise((resolve, reject) => {

		try {
			extractZip(zipFilePath, targetDir);
		} catch (e) {
			reject(e);
		}
	})
}

function renameFile (folderPath) {
	try {
		const files = fs.readdirSync(folderPath);
		files.forEach((file, index) => {
			const oldFilePath = path.join(folderPath, file);
			const fileExtension = path.extname(file);
			if (fileExtension === '.doc') {
				const newFileName = path.basename(oldFilePath, fileExtension) + fileExtension + 'x';
				const newFilePath = path.join(folderPath, newFileName);
				fs.renameSync(oldFilePath, newFilePath);
			}
		});
	} catch (err) {
		console.error('操作失败:', err);
	}
}

function readDirectory (dir) {
	return new Promise((resolve, reject) => {
		// 读取目录内容
		fs.readdir(dir, (err, files) => {
			if (err) {
				console.error(`无法读取目录: ${dir}`, err);
				return;
			}
			resolve(files);
		});
	})
}

/**
 * 删除指定目录下的所有文件
 * @param {string} dir - 要清空的目录路径
 */
async function clearDirectory (dir) {
	if (!fs.existsSync(dir)) {
		console.warn(`目录不存在: ${dir}`);
		return;
	}

	// 读取目录内容
	const items = fs.readdirSync(dir);

	items.forEach(item => {
		const itemPath = path.join(dir, item);
		const stats = fs.statSync(itemPath);

		if (stats.isDirectory()) {
			// 如果是目录，递归删除
			clearDirectory(itemPath); // 递归删除子目录
			fs.rmdirSync(itemPath); // 删除空目录
		} else {
			// 如果是文件，直接删除
			fs.unlinkSync(itemPath);
		}
	});

}

/**
 * 解压 ZIP 文件到指定目录
 * @param {string} zipFilePath - ZIP 文件路径
 * @param {string} targetDir - 解压目标目录
 * @param mkDir
 * @param {string} sourceEncoding - 源文件编码，默认为 'gbk'
 */
async function extractZip (zipFilePath, targetDir, mkDir = true, sourceEncoding = 'gbk') {
	if (!fs.existsSync(zipFilePath)) {
		console.error(`ZIP 文件不存在: ${zipFilePath}`);
		return;
	}
	const zip = new AdmZip(zipFilePath);
	const zipEntries = zip.getEntries();

	zipEntries.forEach(entry => {
		// 将文件名从二进制 Buffer 转换为指定编码
		const decodedName = iconv.decode(Buffer.from(entry.rawEntryName, 'binary'), sourceEncoding);
		let targetPath = path.join(targetDir, decodedName);

		try {
			if (entry.isDirectory) {
				// 如果是目录，创建目录
				fs.mkdirSync(targetPath, { recursive: true });
			} else {
				// 如果是文件，解压文件
				let arr = targetPath.split('\\');
				arr = arr.splice(0, arr.length - 1)
				let dirPath = arr.join('\\');
				fs.mkdirSync(dirPath, { recursive: true });

				fs.writeFileSync(targetPath, entry.getData());
			}
		} catch (error) {
			console.error(`解压文件时出错: ${targetPath}`, error);
		}
	});

}

/**
 * 递归解压目录中的 ZIP 文件
 * @param {string} dir - 要递归解压的目录
 * @param mkDir
 */
async function recursivelyExtractZips (dir, mkDir = true) {
	if (!fs.existsSync(dir)) {
		console.error(`目录不存在: ${dir}`);
		return;
	}

	// 读取目录内容
	const items = fs.readdirSync(dir);
	for (const item of items) {
		const itemPath = path.join(dir, item);
		const stats = fs.statSync(itemPath);

		if (stats.isDirectory()) {
			// 如果是目录，递归处理
			await recursivelyExtractZips(itemPath, mkDir);
		} else if (stats.isFile() && path.extname(item).toLowerCase() === '.zip') {
			// 如果是 ZIP 文件，解压并递归处理解压后的目录
			let extractDir = path.join(dir, path.basename(item, '.zip'));
			if (!mkDir) {
				let a = extractDir.split('\\');
				a.splice(a.length - 1, 1)
				extractDir = a.join('\\');
				Log.info('extractDir', extractDir);
				await extractZip(itemPath, extractDir, mkDir);
			} else {
				await extractZip(itemPath, extractDir, mkDir);
				await recursivelyExtractZips(extractDir, mkDir); // 递归解压解压后的目录
			}
		}
	}
}

/**
 * 删除指定目录下的所有 .zip 文件
 * @param {string} directory - 要遍历的目录路径
 */

async function deleteZipFiles (directory = target) {
	// 读取目录内容
	fs.readdir(directory, { withFileTypes: true }, (err, files) => {
		if (err) {
			console.error(`无法读取目录 ${directory}: ${err.message}`);
			return;
		}

		// 遍历目录中的每个文件或文件夹
		files.forEach(async (file) => {
			const filePath = path.join(directory, file.name);

			if (file.isDirectory()) {
				// 如果是目录，递归调用
				await deleteZipFiles(filePath);
			} else if (file.isFile() && path.extname(file.name) === '.zip') {
				// 如果是 .zip 文件，删除它
				fs.unlink(filePath, (err) => {
					if (err) {
						console.error(`无法删除文件 ${filePath}: ${err.message}`);
					} else {
					}
				});
			}
		});
	});
}

/**
 * 删除指定目录下的所有文件
 * @param {string} directory - 要遍历的目录路径
 */
async function deleteFiles (directory) {
	// 读取目录中的所有文件
	fs.readdir(directory, (err, files) => {
		if (err) {
			console.error('无法读取目录:', err);
			return;
		}

		files.forEach(file => {
			const filePath = path.join(directory, file);

			// 获取文件状态
			fs.stat(filePath, (err, stats) => {
				if (err) {
					console.error(`无法获取文件状态 ${filePath}:`, err);
					return;
				}

				// 如果不是目录，则删除文件
				if (!stats.isDirectory()) {
					fs.unlink(filePath, err => {
						if (err) {
							console.error(`无法删除文件 ${filePath}:`, err);
						} else {
							console.log(`已删除文件: ${filePath}`);
						}
					});
				}
			});
		});
	});
}

module.exports = {
	extract, renameFile, readDirectory, clearDirectory, recursivelyExtractZips, deleteZipFiles, extractZip, deleteFiles
}
